home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / writeback.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  4.9 KB  |  163 lines
  1. /*
  2.  * include/linux/writeback.h
  3.  */
  4. #ifndef WRITEBACK_H
  5. #define WRITEBACK_H
  6.  
  7. #include <linux/sched.h>
  8. #include <linux/fs.h>
  9.  
  10. struct backing_dev_info;
  11.  
  12. extern spinlock_t inode_lock;
  13. extern struct list_head inode_in_use;
  14. extern struct list_head inode_unused;
  15.  
  16. /*
  17.  * Yes, writeback.h requires sched.h
  18.  * No, sched.h is not included from here.
  19.  */
  20. static inline int task_is_pdflush(struct task_struct *task)
  21. {
  22.     return task->flags & PF_FLUSHER;
  23. }
  24.  
  25. #define current_is_pdflush()    task_is_pdflush(current)
  26.  
  27. /*
  28.  * fs/fs-writeback.c
  29.  */
  30. enum writeback_sync_modes {
  31.     WB_SYNC_NONE,    /* Don't wait on anything */
  32.     WB_SYNC_ALL,    /* Wait on every mapping */
  33. };
  34.  
  35. /*
  36.  * A control structure which tells the writeback code what to do.  These are
  37.  * always on the stack, and hence need no locking.  They are always initialised
  38.  * in a manner such that unspecified fields are set to zero.
  39.  */
  40. struct writeback_control {
  41.     struct backing_dev_info *bdi;    /* If !NULL, only write back this
  42.                        queue */
  43.     enum writeback_sync_modes sync_mode;
  44.     unsigned long *older_than_this;    /* If !NULL, only write back inodes
  45.                        older than this */
  46.     long nr_to_write;        /* Write this many pages, and decrement
  47.                        this for each page written */
  48.     long pages_skipped;        /* Pages which were not written */
  49.  
  50.     /*
  51.      * For a_ops->writepages(): is start or end are non-zero then this is
  52.      * a hint that the filesystem need only write out the pages inside that
  53.      * byterange.  The byte at `end' is included in the writeout request.
  54.      */
  55.     loff_t range_start;
  56.     loff_t range_end;
  57.  
  58.     unsigned nonblocking:1;        /* Don't get stuck on request queues */
  59.     unsigned encountered_congestion:1; /* An output: a queue is full */
  60.     unsigned for_kupdate:1;        /* A kupdate writeback */
  61.     unsigned for_reclaim:1;        /* Invoked from the page allocator */
  62.     unsigned for_writepages:1;    /* This is a writepages() call */
  63.     unsigned range_cyclic:1;    /* range_start is cyclic */
  64.     unsigned more_io:1;        /* more io to be dispatched */
  65.     /*
  66.      * write_cache_pages() won't update wbc->nr_to_write and
  67.      * mapping->writeback_index if no_nrwrite_index_update
  68.      * is set.  write_cache_pages() may write more than we
  69.      * requested and we want to make sure nr_to_write and
  70.      * writeback_index are updated in a consistent manner
  71.      * so we use a single control to update them
  72.      */
  73.     unsigned no_nrwrite_index_update:1;
  74. };
  75.  
  76. /*
  77.  * fs/fs-writeback.c
  78.  */    
  79. void writeback_inodes(struct writeback_control *wbc);
  80. int inode_wait(void *);
  81. void sync_inodes_sb(struct super_block *, int wait);
  82. void sync_inodes(int wait);
  83.  
  84. /* writeback.h requires fs.h; it, too, is not included from here. */
  85. static inline void wait_on_inode(struct inode *inode)
  86. {
  87.     might_sleep();
  88.     wait_on_bit(&inode->i_state, __I_LOCK, inode_wait,
  89.                             TASK_UNINTERRUPTIBLE);
  90. }
  91. static inline void inode_sync_wait(struct inode *inode)
  92. {
  93.     might_sleep();
  94.     wait_on_bit(&inode->i_state, __I_SYNC, inode_wait,
  95.                             TASK_UNINTERRUPTIBLE);
  96. }
  97.  
  98.  
  99. /*
  100.  * mm/page-writeback.c
  101.  */
  102. int wakeup_pdflush(long nr_pages);
  103. void laptop_io_completion(void);
  104. void laptop_sync_completion(void);
  105. void throttle_vm_writeout(gfp_t gfp_mask);
  106.  
  107. /* These are exported to sysctl. */
  108. extern int dirty_background_ratio;
  109. extern int vm_dirty_ratio;
  110. extern int dirty_writeback_interval;
  111. extern int dirty_expire_interval;
  112. extern int vm_highmem_is_dirtyable;
  113. extern int block_dump;
  114. extern int laptop_mode;
  115.  
  116. extern unsigned long determine_dirtyable_memory(void);
  117.  
  118. extern int dirty_ratio_handler(struct ctl_table *table, int write,
  119.         struct file *filp, void __user *buffer, size_t *lenp,
  120.         loff_t *ppos);
  121.  
  122. struct ctl_table;
  123. struct file;
  124. int dirty_writeback_centisecs_handler(struct ctl_table *, int, struct file *,
  125.                       void __user *, size_t *, loff_t *);
  126.  
  127. void get_dirty_limits(long *pbackground, long *pdirty, long *pbdi_dirty,
  128.          struct backing_dev_info *bdi);
  129.  
  130. void page_writeback_init(void);
  131. void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
  132.                     unsigned long nr_pages_dirtied);
  133.  
  134. static inline void
  135. balance_dirty_pages_ratelimited(struct address_space *mapping)
  136. {
  137.     balance_dirty_pages_ratelimited_nr(mapping, 1);
  138. }
  139.  
  140. typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
  141.                 void *data);
  142.  
  143. int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0);
  144. int generic_writepages(struct address_space *mapping,
  145.                struct writeback_control *wbc);
  146. int write_cache_pages(struct address_space *mapping,
  147.               struct writeback_control *wbc, writepage_t writepage,
  148.               void *data);
  149. int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
  150. int sync_page_range(struct inode *inode, struct address_space *mapping,
  151.             loff_t pos, loff_t count);
  152. int sync_page_range_nolock(struct inode *inode, struct address_space *mapping,
  153.                loff_t pos, loff_t count);
  154. void set_page_dirty_balance(struct page *page, int page_mkwrite);
  155. void writeback_set_ratelimit(void);
  156.  
  157. /* pdflush.c */
  158. extern int nr_pdflush_threads;    /* Global so it can be exported to sysctl
  159.                    read-only. */
  160.  
  161.  
  162. #endif        /* WRITEBACK_H */
  163.